package com.mall.web.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ConnectException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLDecoder;
import java.util.Date;
import java.util.List;
import java.util.Map;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;

import com.alibaba.fastjson.JSON;
import com.ibm.icu.text.SimpleDateFormat;
import com.mall.constant.ReqAttributeKey;
import com.mall.constant.TypeCommOnlyKeyConstant;
import com.mall.web.control.app.pay.MyX509TrustManager;
import com.mall.web.vo.AjaxResult;
import com.mall.web.vo.AjaxResultType;

import net.sf.json.JSONObject;

public class HttpUtil {

	// 用户登录的url
	public static final String URL_USER_LOGIN = "/user/login/login.htm";
	//微商登陆
	public static final String URL_USER_LOGIN_WEISHANG = "/weishang/user/login.htm";
	//maidian微商登陆
	public static final String URL_USER_LOGIN_MAIDIAN = "/maidian/user/login.htm";
	//eshop登陆
	public static final String URL_USER_LOGIN_ESHOP = "/eshop/pcEshopLogin.htm";
	
	
	// 卖家登录的url
	public static final String URL_SELLER_LOGIN = "/seller/login.htm";

	// 用户登录的url
	public static final String URL_COMMKEY_ERROR = "/user/login/login.htm";

	static final Logger log = org.slf4j.LoggerFactory.getLogger(HttpUtil.class);

	/**
	 * 输出Json内容到客户端，并关闭连接
	 * 
	 * @param result
	 * @param response
	 */
	public static void ajaxJsonpOutput(String callback, Object result, ServletResponse response) {
		PrintWriter out = null;
		try {
			String jsonResult = JSON.toJSONString(result);
			if (StringUtils.isNoneBlank(callback)) {
				jsonResult = callback + "([" + jsonResult + "] );";
			}
			out = response.getWriter();
			out.write(jsonResult);
		} catch (IOException e) {
			log.error(e.getMessage(), e);
		} finally {
			if (out != null) {
				out.close();
			}
		}
	}

	/**
	 * 输出Json内容到客户端，并关闭连接
	 * 
	 * @param result
	 * @param response
	 */
	public static void ajaxOutput(AjaxResult result, ServletResponse response) {
		PrintWriter out = null;
		try {
			if (result == null) {
				result = new AjaxResult();
				result.setCode(AjaxResultType.FAIL.getValue());
			}
			String jsonResult = JSON.toJSONString(result);
			out = response.getWriter();
			out.write(jsonResult);
		} catch (IOException e) {
			log.error(e.getMessage(), e);
		} finally {
			if (out != null) {
				out.close();
			}
		}
	}

	public static String getIpAddress(HttpServletRequest request) {
		String ip = request.getHeader("X-Forwarded-For");
		if (StringUtils.isBlank(ip) || StringUtils.equalsIgnoreCase(ip, "unknown")) {
			ip = request.getHeader("Proxy-Client-IP");
		}
		if (StringUtils.isBlank(ip) || StringUtils.equalsIgnoreCase(ip, "unknown")) {
			ip = request.getHeader("WL-Proxy-Client-IP");
		}
		if (StringUtils.isBlank(ip) || StringUtils.equalsIgnoreCase(ip, "unknown")) {
			ip = request.getHeader("HTTP_CLIENT_IP");
		}
		if (StringUtils.isBlank(ip) || StringUtils.equalsIgnoreCase(ip, "unknown")) {
			ip = request.getHeader("HTTP_X_FORWARDED_FOR");
		}
		if (StringUtils.isBlank(ip) || StringUtils.equalsIgnoreCase(ip, "unknown")) {
			ip = request.getRemoteAddr();
		}
		if (StringUtils.isNotBlank(ip) && StringUtils.indexOf(ip, ",") > 0) {
			String[] ipArray = StringUtils.split(ip, ",");
			ip = ipArray[0];
		}
		return ip;
	}

	/**
	 * 向指定URL发送GET方法的请求
	 * 
	 * @param url
	 *            发送请求的URL
	 * @param param
	 *            请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
	 * @return URL 所代表远程资源的响应结果
	 */
	public static String sendGet(String url, String param) {
		String result = "";
		BufferedReader in = null;
		try {
			String urlNameString = url + "?" + param;
			URL realUrl = new URL(urlNameString);
			// 打开和URL之间的连接
			URLConnection connection = realUrl.openConnection();
			// 设置通用的请求属性
			connection.setRequestProperty("accept", "*/*");
			connection.setRequestProperty("connection", "Keep-Alive");
			connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
			// 建立实际的连接
			connection.connect();
			// 获取所有响应头字段
			Map<String, List<String>> map = connection.getHeaderFields();
			// 遍历所有的响应头字段
			// for (String key : map.keySet()) {
			// System.out.println(key + "--->" + map.get(key));
			// }
			// 定义 BufferedReader输入流来读取URL的响应
			in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
			String line;
			while ((line = in.readLine()) != null) {
				result += line;
			}
		} catch (Exception e) {
			System.out.println("发送GET请求出现异常！" + e);
		}
		// 使用finally块来关闭输入流
		finally {
			try {
				if (in != null) {
					in.close();
				}
			} catch (Exception e2) {
				log.error(e2.getMessage(), e2);
			}
		}
		return result;
	}

	/**
	 * 向指定 URL 发送POST方法的请求
	 * 
	 * @param url
	 *            发送请求的 URL
	 * @param param
	 *            请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
	 * @return 所代表远程资源的响应结果
	 */
	public static String sendPost(String url, String param) {
		PrintWriter out = null;
		BufferedReader in = null;
		String result = "";
		try {
			URL realUrl = new URL(url);
			// 打开和URL之间的连接
			URLConnection conn = realUrl.openConnection();
			// 设置通用的请求属性
			conn.setRequestProperty("accept", "*/*");
			conn.setRequestProperty("connection", "Keep-Alive");
			conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
			// 发送POST请求必须设置如下两行
			conn.setDoOutput(true);
			conn.setDoInput(true);
			// 获取URLConnection对象对应的输出流
			out = new PrintWriter(conn.getOutputStream());
			// 发送请求参数
			out.print(param);
			// flush输出流的缓冲
			out.flush();
			// 定义BufferedReader输入流来读取URL的响应
			in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
			String line;
			while ((line = in.readLine()) != null) {
				result += line;
			}
		} catch (Exception e) {
			System.out.println("发送 POST 请求出现异常！" + e);
		}
		// 使用finally块来关闭输出流、输入流
		finally {
			try {
				if (out != null) {
					out.close();
				}
				if (in != null) {
					in.close();
				}
			} catch (IOException ex) {
				log.error(ex.getMessage(), ex);
			}
		}
		return result;
	}

	public static Integer getIntegerValueFromRequest(HttpServletRequest request, String key) {
		String value = request.getParameter(key);
		Integer returnValue = null;
		if (StringUtils.isNotBlank(value)) {
			try {
				returnValue = Integer.parseInt(value);
			} catch (Exception e) {
			}
		}

		return returnValue;
	}

	public static Long getLongValueFromRequest(HttpServletRequest request, String key) {
		String value = request.getParameter(key);
		Long returnValue = null;
		if (StringUtils.isNotBlank(value)) {
			try {
				returnValue = Long.parseLong(value);
			} catch (Exception e) {
			}
		}
		return returnValue;
	}

	public static String getStringValueFromRequest(HttpServletRequest request, String key) {
		String value = request.getParameter(key);
		String returnValue = null;
		if (StringUtils.isNotBlank(value)) {
			try {
				returnValue = String.valueOf(value);
			} catch (Exception e) {
			}
		}
		return returnValue;
	}

	public static Integer getIntegerValueHasDefaultFromRequest(HttpServletRequest request, String key,
			int defaultValue) {
		String value = request.getParameter(key);
		Integer returnValue = null;

		if (StringUtils.isBlank(value)) {
			return defaultValue;
		}

		if (StringUtils.isNotBlank(value)) {
			try {
				returnValue = Integer.parseInt(value);
			} catch (Exception e) {
				return defaultValue;
			}
		}
		return returnValue;
	}
	public static Long getLongValueHasDefaultFromRequest(HttpServletRequest request, String key,
			Long defaultValue) {
		String value = request.getParameter(key);
		Long returnValue = null;

		if (StringUtils.isBlank(value)) {
			return defaultValue;
		}

		if (StringUtils.isNotBlank(value)) {
			try {
				returnValue = Long.parseLong(value);
			} catch (Exception e) {
				return defaultValue;
			}
		}
		return returnValue;
	}
	/**
	 * 时间转换
	 * @param request
	 * @param key
	 * @return
	 */
	public static Date getDateValueFromRequest(HttpServletRequest request, String key) {
		String value = request.getParameter(key);
		Date returnValue = null;
		if (StringUtils.isNotBlank(value)) {
			try {
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				returnValue = sdf.parse(value);
			} catch (Exception e) {
			}
		}
		return returnValue;
	}

	/**
	 * 中文转码
	 * 
	 * @param request
	 * @param key
	 * @return
	 */
	public static String getURLDecoderValueFromRequest(HttpServletRequest request, String key) {
		String value = request.getParameter(key);
		String returnValue = null;

		if (StringUtils.isNotBlank(value)) {
			try {
				returnValue = URLDecoder.decode(URLDecoder.decode(value, "UTF-8"), "UTF-8");
			} catch (Exception e) {
			}
		}
		return returnValue;
	}

	/**
	 * 返回上一个访问的页面
	 * 
	 * @param request
	 * @return
	 */
	public static String getHttpReferer(HttpServletRequest request) {
		return request.getHeader("Referer");
	}

	/**
	 * 获取commkeyid
	 * 
	 * @param request
	 * @return
	 */
	public static Integer getCommkeyId(HttpServletRequest request, HttpServletResponse response) {
		Integer commkeyid = null;

		commkeyid = getIntegerValueFromRequest(request, ReqAttributeKey.COOKIE_FOR_COMMKEYID);
		
//		String commkeyidCookie = CookieUtil.getCookieValue(request, ReqAttributeKey.COOKIE_FOR_COMMKEYID);
//		
//		try {
//			if (StringUtils.isNotBlank(commkeyidCookie)) {
//				commkeyid = Integer.parseInt(commkeyidCookie);
////				CookieUtil.setCookie(response, ReqAttributeKey.COOKIE_FOR_COMMKEYID, commkeyidCookie);
//				WebUtil.setCurrentCommOnlyKeySessionAndCookies(request, response, commkeyid);
//				return commkeyid;
//			}
//		} catch (Exception e) {
//		}
		
		
		if (commkeyid != null && commkeyid > 0) {
//			CookieUtil.setCookie(response, ReqAttributeKey.COOKIE_FOR_COMMKEYID, commkeyid + "");
			WebUtil.setCurrentCommOnlyKeySessionAndCookies(request, response, commkeyid);
			return commkeyid;
		}else{
			if (HttpUrlTypeUtil.isEshopUrl(request)) {
//				CookieUtil.setCookie(response, ReqAttributeKey.COOKIE_FOR_COMMKEYID, 2 + "");
				WebUtil.setCurrentCommOnlyKeySessionAndCookies(request, response, 2);
				return TypeCommOnlyKeyConstant.TYPE_MAIGEDIAN;
			}
			if (HttpUrlTypeUtil.isWeiShang(request)) {
				//CookieUtil.setCookie(response, ReqAttributeKey.COOKIE_FOR_COMMKEYID, commkeyid + "");
				WebUtil.setCurrentCommOnlyKeySessionAndCookies(request, response, TypeCommOnlyKeyConstant.TYPE_MAIDIAN);
				return TypeCommOnlyKeyConstant.TYPE_MAIDIAN;
			}
			if (HttpUrlTypeUtil.isPs(request)) {
				//CookieUtil.setCookie(response, ReqAttributeKey.COOKIE_FOR_COMMKEYID, commkeyid + "");
				WebUtil.setCurrentCommOnlyKeySessionAndCookies(request, response, 7);
				return TypeCommOnlyKeyConstant.TYPE_PS;
			}
			if (HttpUrlTypeUtil.isMaidian(request)) {
//				CookieUtil.setCookie(response, ReqAttributeKey.COOKIE_FOR_COMMKEYID, 2 + "");
				WebUtil.setCurrentCommOnlyKeySessionAndCookies(request, response, TypeCommOnlyKeyConstant.TYPE_MAIDIAN);
				return TypeCommOnlyKeyConstant.TYPE_MAIDIAN;
			}
			if(StringUtils.isNotBlank(CookieUtil.getCookieValue(request, ReqAttributeKey.COOKIE_FOR_COMMKEYID))){
				commkeyid =	Integer.parseInt(CookieUtil.getCookieValue(request, ReqAttributeKey.COOKIE_FOR_COMMKEYID));
			}
			WebUtil.setCurrentCommOnlyKeySessionAndCookies(request, response, commkeyid);
			return commkeyid;
		}
		
		
	}
	
	 /**
     * 发送 https 请求
     * 
     * @param requestUrl 请求地址
     * @param requestMethod 请求方式（GET、POST）
     * @param outputStr 提交的数据
     * @return JSONObject（通过 JSONObject.get(key) 的方式获取 JSON 对象的属性值）
     */
    public static JSONObject httpsRequest(String requestUrl, String requestMethod, String outputStr) {
        
        JSONObject jsonObject = null;
        
        try {
            // 创建 SSLContext 对象，并使用我们指定的信任管理器初始化
            TrustManager[] tm = { new MyX509TrustManager() };
            SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
            sslContext.init(null, tm, new java.security.SecureRandom());
            // 从上述 SSLContext 对象中得到 SSLSocketFactory 对象
            SSLSocketFactory ssf = sslContext.getSocketFactory();
            
            URL url = new URL(requestUrl);
            HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
            conn.setSSLSocketFactory(ssf);
            
            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setUseCaches(false);
            
            // 设置请求方式（GET/POST）
            conn.setRequestMethod(requestMethod);
            
            // 当 outputStr 不为 null 时，向输出流写数据
            if (null != outputStr) {
                OutputStream outputStream = conn.getOutputStream();
                
                // 注意编码格式
                outputStream.write(outputStr.getBytes("UTF-8"));
                outputStream.close();
            }
            
            // 从输入流读取返回内容
            InputStream inputStream = conn.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");
            BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
            String str = null;
            StringBuffer buffer = new StringBuffer();
            
            while ((str = bufferedReader.readLine()) != null) {
                buffer.append(str);
            }
            
            // 释放资源
            bufferedReader.close();
            inputStreamReader.close();
            inputStream.close();
            inputStream = null;
            conn.disconnect();
            jsonObject = JSONObject.fromObject(buffer.toString());
        } catch (ConnectException ce) {
            log.error(" 连接超时：{}", ce);
        } catch (Exception e) {
            log.error("https 请求异常：{}", e);
        }
        
        return jsonObject;
    }

	

}
